import { NextResponse } from 'next/server';
import { query } from '@/utils/db';
import { RowDataPacket } from 'mysql2/promise';
import jwt from 'jsonwebtoken';

export async function GET(request: Request) {
  try {
    console.log('=== 开始处理/api/auth/me请求 ===');
    console.log('请求URL:', request.url);
    
    // 检查授权头
    const authHeader = request.headers.get('Authorization');
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      console.log('未提供授权头或格式不正确');
      return NextResponse.json(
        { error: '未授权访问' },
        { status: 401 }
      );
    }

    const token = authHeader.substring(7); // 去掉"Bearer "前缀
    console.log('收到的token长度:', token.length);
    
    // JWT密钥
    const secret = process.env.JWT_SECRET || 'xiaoyoubao_default_jwt_secret_key_please_change_in_production_environment_2023';
    
    // 验证token
    let decodedToken;
    try {
      decodedToken = jwt.verify(token, secret);
      
      // 验证解析出的token是否包含用户ID
      if (!decodedToken || typeof decodedToken !== 'object') {
        console.error('JWT验证失败: 解析结果不是有效对象');
        return NextResponse.json(
          { error: '无效的令牌结构' },
          { status: 401 }
        );
      }
      
      // 检查是否存在id属性
      if (!decodedToken.id) {
        console.error('JWT验证失败: 令牌中缺少用户ID');
        return NextResponse.json(
          { error: '无效的令牌内容：缺少用户ID' },
          { status: 401 }
        );
      }
      
      console.log('JWT验证成功，用户ID:', (decodedToken as any).id);
    } catch (error) {
      console.error('JWT验证失败:', error);
      return NextResponse.json(
        { error: '无效的令牌' },
        { status: 401 }
      );
    }

    // 从数据库中获取用户信息
    const userId = (decodedToken as any).id;
    console.log('准备查询用户数据，用户ID:', userId);
    
    // 添加更多错误检查
    if (!userId || isNaN(Number(userId))) {
      console.error('无效的用户ID:', userId);
      return NextResponse.json(
        { error: '无效的用户ID' },
        { status: 400 }
      );
    }
    
    // 先测试数据库连接
    try {
      await query('SELECT 1 AS connection_test');
      console.log('数据库连接测试成功');
    } catch (connError) {
      console.error('数据库连接测试失败:', connError);
      return NextResponse.json(
        { error: '数据库连接失败' },
        { status: 500 }
      );
    }
    
    const userQuery = `
      SELECT 
        u.id, 
        u.username, 
        u.email,
        u.avatar,
        u.is_company_admin,
        c.id as company_id,
        c.name as company_name,
        c.industry as company_industry
      FROM users u
      LEFT JOIN companies c ON u.id = c.admin_user_id
      WHERE u.id = ?
    `;
    
    console.log('执行SQL查询:', userQuery);
    console.log('查询参数:', userId);
    
    try {
      // 执行查询
      const [userResults] = await query<RowDataPacket[]>(userQuery, [userId]);
      
      // 详细记录查询结果状态
      console.log('查询结果类型:', typeof userResults);
      console.log('查询结果是否为数组:', Array.isArray(userResults));
      console.log('查询结果长度:', Array.isArray(userResults) ? userResults.length : 'N/A');
      
      if (!userResults) {
        console.error('查询返回了null或undefined');
        return NextResponse.json(
          { error: '数据库查询返回了无效结果' },
          { status: 500 }
        );
      }
      
      if (userResults.length === 0) {
        console.log(`未找到用户数据，用户ID ${userId} 在数据库中不存在`);
        return NextResponse.json(
          { error: '用户不存在' },
          { status: 404 }
        );
      }

      // 数据库查询结果是数组，取第一个元素
      const userResult = userResults[0];
      
      // 检查userResult是否为有效对象
      if (!userResult) {
        console.error('查询结果的第一个元素无效');
        return NextResponse.json(
          { error: '查询结果无效' },
          { status: 500 }
        );
      }
      
      // 检查必要的字段是否存在
      console.log('用户记录包含的字段:', Object.keys(userResult).join(', '));
      
      if (!userResult.id) {
        console.error('用户记录中缺少id字段');
        return NextResponse.json(
          { error: '用户数据结构不完整: 缺少id' },
          { status: 500 }
        );
      }
      
      if (!userResult.username) {
        console.error('用户记录中缺少username字段');
        return NextResponse.json(
          { error: '用户数据结构不完整: 缺少username' },
          { status: 500 }
        );
      }
      
      // 安全日志记录，只记录部分敏感信息
      console.log('用户数据获取成功, 记录内容:', JSON.stringify({
        id: userResult.id,
        username: userResult.username,
        has_email: Boolean(userResult.email),
        has_avatar: Boolean(userResult.avatar),
        is_company_admin: Boolean(userResult.is_company_admin),
        has_company: Boolean(userResult.company_id)
      }));

      // 构建用户信息对象，使用可选链和默认值防止空值错误
      const user = {
        id: userResult.id,
        username: userResult.username,
        email: userResult.email || null,
        avatar: userResult.avatar || null,
        is_company_admin: Boolean(userResult.is_company_admin),
        company_id: userResult.company_id || null,
        company: userResult.company_name || null,
        company_industry: userResult.company_industry || null
      };

      console.log('处理成功，返回用户数据');
      return NextResponse.json({ user });
    } catch (dbError) {
      // 详细记录数据库错误
      console.error('数据库查询错误详情:');
      console.error('错误消息:', (dbError as Error).message);
      console.error('错误堆栈:', (dbError as Error).stack);
      
      if ((dbError as any).code) {
        console.error('MySQL错误代码:', (dbError as any).code);
        console.error('SQL状态:', (dbError as any).sqlState);
        console.error('错误编号:', (dbError as any).errno);
      }
      
      return NextResponse.json(
        { error: `数据库查询错误: ${(dbError as Error).message}` },
        { status: 500 }
      );
    }
  } catch (error) {
    // 记录异常详情
    console.error('获取用户信息失败:');
    console.error('错误类型:', error instanceof Error ? error.constructor.name : typeof error);
    console.error('错误消息:', error instanceof Error ? error.message : String(error));
    console.error('错误堆栈:', error instanceof Error ? error.stack : '无堆栈信息');
    
    return NextResponse.json(
      { error: `获取用户信息失败: ${error instanceof Error ? error.message : String(error)}` },
      { status: 500 }
    );
  }
} 